home *** CD-ROM | disk | FTP | other *** search
/ Aminet 48 / Aminet 48 (2002)(GTI - Schatztruhe)[!][Apr 2002].iso / Aminet / util / misc / KeyMapEd.lha / KeyMapEd / Source / KME_KeyMapIO.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-03-14  |  15.2 KB  |  507 lines
  1. /*
  2.  * Key Map Editor ver 1.0
  3.  * Key Map IO
  4.  *
  5.  * by: Tim Friest
  6.  * on: January 1, 1989
  7.  */
  8.  
  9. #include "KME_Includes.h"
  10. #include "KME_Protos.h"
  11. #include "KME_Defs.h"
  12. #include "KME_Globals.h"
  13.  
  14. #define    LongToByteArr(a, l)    a[3] = (l & 0x000000FF); a[2] = ((l & 0x0000FF00)>>8); a[1] = ((l & 0x00FF0000)>>16); a[0] = ((l & 0xFF000000)>>24)
  15.  
  16. #define    HUNK_HEADER    0x3F3
  17. #define    HUNK_CODE    0x3E9
  18. #define    HUNK_RELOC32    0x3EC
  19. #define    HUNK_END    0x3F2
  20.  
  21. struct RelocNode {
  22.     struct RelocNode *Next;
  23.     ULONG Offset;
  24. };
  25.  
  26. struct KeyMap_Hunk {
  27.     ULONG    Hunk;
  28.     ULONG    Length;
  29.     struct KeyMapNode    kh_KeyMapNode;
  30.     UBYTE    kh_LoKeyMapTypes[0x40];
  31.     ULONG    kh_LoKeyMap[0x40];
  32.     UBYTE    kh_LoCapsable[0x08];
  33.     UBYTE    kh_LoRepeatable[0x08];
  34.     UBYTE    kh_HiKeyMapTypes[0x38];
  35.     ULONG    kh_HiKeyMap[0x38];
  36.     UBYTE    kh_HiCapsable[0x07];
  37.     UBYTE    kh_HiRepeatable[0x07];
  38. };
  39.  
  40. struct KeyMap_Hunk *CodeSegment;
  41. struct RelocNode *RelocList = NULL;
  42.  
  43. extern    struct KeyMapNode *ConvertKeyMap(struct KeyMapNode *);
  44. extern    ULONG MakeCodeSeg(struct KeyMapNode *, char *);
  45. extern    int    InsertRelocList(ULONG);
  46.  
  47. /*
  48.  * KeyMapIO
  49.  *  
  50.  * parameters:    Filename - String pointer to filename
  51.  *        Option   - IO option (Read or Write)
  52.  */
  53. void KeyMapIO(filename, Option)
  54. char     *filename;
  55. int    Option;
  56. {
  57.     if (Option == LOAD) {
  58.         if ((filename = ProcFileReq("Load")) != NULL) {
  59.             if (!ReadKeyMap(filename))
  60.                 KeyMapNode = MakeNewKeyMap();
  61.             UpdateDisplay(GadgetList, KeyMapNode, TRUE);
  62.         }
  63.         else
  64.             if (!(CheckResource(RF_KeyMap)))
  65.                 KeyMapNode = MakeNewKeyMap();
  66.                 
  67.     } else if (Option == SAVE) {
  68.         if ((filename = ProcFileReq("Save")) != NULL)
  69.             WriteKeyMap(filename);
  70.     }
  71. }
  72.  
  73. /*
  74.  * ReadKeyMap
  75.  *
  76.  * parameter:    Filename - Filename of KeyMap to read
  77.  * returns:    Result - Success of operation (TRUE or FALSE)
  78.  */
  79. int ReadKeyMap(filename)
  80. char    *filename;
  81. {
  82.     if (CheckResource(RF_KeyMap)) {
  83.         FreeKeyMap(KeyMapNode);
  84.         ClearResource(RF_KeyMap);
  85.     }
  86.     if ((KeyMapSegment = LoadSeg(filename)) == NULL) {
  87.         Write(Output(), "Error ReadKeyMap: LoadSeg failed\n", 33);
  88.         return(FALSE);
  89.     }
  90.     if ((KeyMapNode = ConvertKeyMap((struct KeyMapNode *)BADDR((KeyMapSegment+1)))) == NULL) {
  91.         Write(Output(), "Error ReadKeyMap: ConvertKeyMap Failed\n", 39);
  92.         return(FALSE);
  93.     }
  94.     UnLoadSeg(KeyMapSegment);
  95.     FlagResource(RF_KeyMap);
  96.     return(TRUE);
  97. }
  98.  
  99. /*
  100.  * Convert Key Map Strings to freememable places
  101.  *
  102.  * parameters:    KeyMapNode - Key Map Node structure
  103.  *
  104.  * returns:    Success - TRUE or FALSE
  105.  */
  106. struct KeyMapNode *ConvertKeyMap(OldKeyMapNode)
  107. struct KeyMapNode *OldKeyMapNode;
  108. {
  109.     USHORT KeyCode;
  110.     struct HalfKeyMap *HalfKeyMap;
  111.     int length, maphalf;
  112.     UBYTE len, HeaderLen;
  113.     struct KeyMapNode *NewKeyMapNode;
  114.     UBYTE *old, *new;
  115.  
  116.     if ((NewKeyMapNode = (struct KeyMapNode *)AllocMem((KeyNodeSize + KeyMapSize), MEMF_CLEAR)) == NULL) {
  117.         Write(Output(), "Memory Allocation failed, ConvertKeyMap:KeyMap\n", 47);
  118.         return(NULL);
  119.     }
  120.     memcpy((UBYTE *)NewKeyMapNode, (UBYTE *)OldKeyMapNode, KeyNodeSize);
  121.     new = ((UBYTE *)NewKeyMapNode) + KeyNodeSize;
  122.     memcpy(new, OldKeyMapNode->kn_KeyMap.km_LoKeyMapTypes, 0x40);
  123.     NewKeyMapNode->kn_KeyMap.km_LoKeyMapTypes = new;
  124.     new += 0x40;
  125.     memcpy(new, (UBYTE *)OldKeyMapNode->kn_KeyMap.km_LoKeyMap, (0x40*4));
  126.     NewKeyMapNode->kn_KeyMap.km_LoKeyMap = (long *)new;
  127.     new += (0x40 * 4);
  128.     memcpy(new, OldKeyMapNode->kn_KeyMap.km_LoCapsable, 0x08);
  129.     NewKeyMapNode->kn_KeyMap.km_LoCapsable = new;
  130.     new += 0x08;
  131.     memcpy(new, OldKeyMapNode->kn_KeyMap.km_LoRepeatable, 0x08);
  132.     NewKeyMapNode->kn_KeyMap.km_LoRepeatable = new;
  133.     new += 0x08;
  134.     memcpy(new, OldKeyMapNode->kn_KeyMap.km_HiKeyMapTypes, 0x38);
  135.     NewKeyMapNode->kn_KeyMap.km_HiKeyMapTypes = new;
  136.     new += 0x38;
  137.     memcpy(new, (UBYTE *)OldKeyMapNode->kn_KeyMap.km_HiKeyMap, (0x38*4));
  138.     NewKeyMapNode->kn_KeyMap.km_HiKeyMap = (long *)new;
  139.     new += (0x38 * 4);
  140.     memcpy(new, OldKeyMapNode->kn_KeyMap.km_HiCapsable, 0x07);
  141.     NewKeyMapNode->kn_KeyMap.km_HiCapsable = new;
  142.     new += 0x07;
  143.     memcpy(new, OldKeyMapNode->kn_KeyMap.km_HiRepeatable, 0x07);
  144.     NewKeyMapNode->kn_KeyMap.km_HiRepeatable = new;
  145.  
  146.     HalfKeyMap = (struct HalfKeyMap *)&NewKeyMapNode->kn_KeyMap;
  147.     maphalf = 0;
  148.     KeyCode = 0x00;
  149.     while (maphalf < 2)
  150.         if (((maphalf == 0) && (KeyCode < 0x40)) || ((maphalf == 1) && (KeyCode < 0x38))) {
  151.              switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  152.                 case KCF_STRING:
  153.                     len = StringKeyLength(HalfKeyMap, KeyCode, &HeaderLen);
  154.                     if ((new = (UBYTE *)AllocMem(len, MEMF_CLEAR)) == NULL) {
  155.                         Write(Output(), "Memory allocation failed, ConvertKeyMap:String\n", 47);
  156.                         return(NULL);
  157.                     }
  158.                     CopyStringKey(HalfKeyMap, KeyCode, new, HeaderLen);
  159.                     HalfKeyMap->KeyMap[KeyCode] = (ULONG)new;
  160.                     break;
  161.                 case KCF_DEAD:
  162.                     len = DeadKeyLength(HalfKeyMap, KeyCode, &HeaderLen);
  163.                     if ((new = (UBYTE *)AllocMem(len, MEMF_CLEAR)) == NULL) {
  164.                         Write(Output(), "Memory allocation failed, ConvertKeyMap:Dead\n", 46);
  165.                         return(NULL);
  166.                     }
  167.                     CopyDeadKey(HalfKeyMap, KeyCode, new, HeaderLen);
  168.                     HalfKeyMap->KeyMap[KeyCode] = (ULONG)new;
  169.             } /* switch */
  170.             KeyCode += 1;
  171.         }
  172.         else {
  173.             KeyCode = 0x00;
  174.             HalfKeyMap = (struct HalfKeyMap *)&NewKeyMapNode->kn_KeyMap.km_HiKeyMapTypes;
  175.             maphalf += 1;
  176.         }
  177.     old = OldKeyMapNode->kn_Node.ln_Name;
  178.     length = strlen(old) + 1;
  179.     if ((new = (UBYTE *)AllocMem(length, MEMF_CLEAR)) == NULL) {
  180.         Write(Output(), "Memory Allocation Failed, ConvertKeyMap:NodeName\n", 49);
  181.         return(NULL);
  182.     }
  183.     strcpy(new, old);
  184.     NewKeyMapNode->kn_Node.ln_Name = (char *)new;
  185.     return(NewKeyMapNode);
  186. }
  187.  
  188. /*
  189.  * Free Key Map
  190.  *
  191.  * parameter:    KeyMapNode - Key Map Node to free
  192.  */
  193. void FreeKeyMap(FreeKeyMapNode)
  194. struct KeyMapNode *FreeKeyMapNode;
  195. {
  196.     UBYTE *buff;
  197.     UBYTE len, headerlen;
  198.     struct HalfKeyMap *HalfKeyMap;
  199.     USHORT KeyCode;
  200.     int maphalf, length;
  201.  
  202.     if ((buff = FreeKeyMapNode->kn_Node.ln_Name) != NULL) {
  203.         length = strlen(buff) + 1;
  204.         FreeMem(buff, length);
  205.     }
  206.     HalfKeyMap = (struct HalfKeyMap *)&FreeKeyMapNode->kn_KeyMap.km_HiKeyMapTypes;
  207.     maphalf = 1;
  208.     KeyCode = 0x37;
  209.     while (maphalf >= 0) {
  210.         KeyCode -= 1;
  211.         switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  212.             case KCF_STRING:
  213.                 buff = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
  214.                 len = StringKeyLength(HalfKeyMap, KeyCode, &headerlen);
  215.                 FreeMem(buff, len);
  216.                 break;
  217.             case KCF_DEAD:
  218.                 buff = (UBYTE *)HalfKeyMap->KeyMap[KeyCode];
  219.                 len = DeadKeyLength(HalfKeyMap, KeyCode, &headerlen);
  220.                 FreeMem(buff, len);
  221.         } /* switch */
  222.         if (KeyCode == 0x00) {
  223.             KeyCode = 0x3F;
  224.             HalfKeyMap = (struct HalfKeyMap *)&FreeKeyMapNode->kn_KeyMap;
  225.             maphalf -= 1;
  226.         }
  227.     } /* while */
  228.     FreeMem((UBYTE *)FreeKeyMapNode, (KeyNodeSize + KeyMapSize));
  229.     ClearFlag(RF_KeyMap);
  230. }
  231.  
  232. /*
  233.  * WriteKeyMap
  234.  *
  235.  * parameter:    Filename - Filename of KeyMap to read
  236.  * returns:    Result - Success of operation (TRUE or FALSE)
  237.  */
  238. int WriteKeyMap(filename)
  239. char    *filename;
  240. {
  241.     BPTR File;
  242.     ULONG CodeLen, RelocLen;
  243.     struct RelocNode *temp, *next;
  244.     UBYTE bytes[4];
  245.     int status = TRUE;
  246.  
  247.     if ((CodeLen = MakeCodeSeg(KeyMapNode, filename)) == NULL) {
  248.         Write(Output(), "HUNK_CODE Creation Error\n", 24);
  249.         goto EndWrite;
  250.     }
  251.     if ((File = Open(filename, MODE_NEWFILE)) == NULL)
  252.         return(FALSE);
  253. /* Creating an executable HUNK */
  254.     LongToByteArr(bytes, HUNK_HEADER);
  255.     if (Write(File, bytes, 4) != 4) {
  256.         Write(Output(), "Write Error, Hunk_Header\n", 25);
  257.         status = FALSE;
  258.         goto EndWrite;
  259.     }
  260. /* No libraries used */
  261.     LongToByteArr(bytes, 0);
  262.     if (Write(File, bytes, 4) != 4) {
  263.         Write(Output(), "Write Error, Hunk_Header libname\n", 34);
  264.         status = FALSE;
  265.         goto EndWrite;
  266.     }
  267. /* Hunk table size */
  268.     LongToByteArr(bytes, 1);
  269.     if (Write(File, bytes, 4) != 4) {
  270.         Write(Output(), "Write Error, Hunk_Header table\n", 31);
  271.         status = FALSE;
  272.         goto EndWrite;
  273.     }
  274. /* First hunk */
  275.     LongToByteArr(bytes, 0);
  276.     if (Write(File, bytes, 4) != 4) {
  277.         Write(Output(), "Write Error, Hunk_Header first hunk\n", 36);
  278.         status = FALSE;
  279.         goto EndWrite;
  280.     }
  281. /* Last hunk */
  282.     LongToByteArr(bytes, 0);
  283.     if (Write(File, bytes, 4) != 4) {
  284.         Write(Output(), "Write Error, Hunk_Header last hunk\n", 35);
  285.         status = FALSE;
  286.         goto EndWrite;
  287.     }
  288. /* write Hunk sizes (number of longwords) */
  289.     LongToByteArr(bytes, ((CodeLen>>2)-2));
  290.     if (Write(File, bytes, 4) != 4) {
  291.         Write(Output(), "Write Error, Hunk_Header sizes\n", 31);
  292.         status = FALSE;
  293.         goto EndWrite;
  294.     }
  295. /* write HUNK_CODE */
  296.     if (Write(File, (UBYTE *)CodeSegment, CodeLen) != CodeLen) {
  297.         Write(Output(), "Write Error, HUNK_CODE\n", 22);
  298.         status = FALSE;
  299.         goto EndWrite;
  300.     }
  301. /* write Hunk_Reloc32 */
  302.     LongToByteArr(bytes, HUNK_RELOC32);
  303.     if (Write(File, bytes, 4) != 4) {
  304.         Write(Output(), "Write Error, Hunk_Reloc32\n", 26);
  305.         status = FALSE;
  306.         goto EndWrite;
  307.     }
  308.     for (temp = RelocList, RelocLen = 0; temp; (temp = temp->Next), RelocLen++);
  309. /* write hunk_reloc32 length (number of longwords) */
  310.     if (Write(File, (UBYTE *)&RelocLen, 4) != 4) {
  311.         Write(Output(), "Write Error, Hunk_Reloc32 Length\n", 33);
  312.         status = FALSE;
  313.         goto EndWrite;
  314.     }
  315. /* write hunk_reloc32 hunk number effected */
  316.     LongToByteArr(bytes, 0);
  317.     if (Write(File, bytes, 4) != 4) {
  318.         Write(Output(), "Write Error, Hunk_Reloc32 hunk number\n", 38);
  319.         status = FALSE;
  320.         goto EndWrite;
  321.     }
  322. /* write hunk_reloc32 offsets */
  323.     for (temp = RelocList; temp; temp = temp->Next)
  324.         if (Write(File, (UBYTE *)&temp->Offset, 4) != 4) {
  325.             Write(Output(), "Write Error, Hunk_Reloc32 offset\n", 33);
  326.             status = FALSE;
  327.             goto EndWrite;
  328.         }
  329. /* write end Hunk_Reloc32 */
  330.     LongToByteArr(bytes, 0);
  331.     if (Write(File, bytes, 4) != 4) {
  332.         Write(Output(), "Write Error, Hunk_Reloc32 end\n", 30);
  333.         status = FALSE;
  334.         goto EndWrite;
  335.     }
  336. /* write Hunk_End */
  337.     LongToByteArr(bytes, HUNK_END);
  338.     if (Write(File, bytes, 4) != 4) {
  339.         Write(Output(), "Write Error, Hunk_End\n", 22);
  340.         status = FALSE;
  341.         goto EndWrite;
  342.     }
  343.  
  344. EndWrite:
  345.     Close(File);
  346.     FreeMem((UBYTE *)CodeSegment, CodeLen);
  347.     for (temp = RelocList; temp; temp = next) {
  348.         next = temp->Next;
  349.         FreeMem((UBYTE *)temp, sizeof(struct RelocNode));
  350.     }
  351.     if (status) {
  352.         SetProtection(filename, 0x02);
  353.         ClearFlag(SF_Modified);
  354.     }
  355.     return(status);
  356. }
  357.  
  358. /*
  359.  * Make Code Segment
  360.  *
  361.  * Convert KeyMap to a HUNK_CODE hunk
  362.  *
  363.  * parameter:    KeyMapNode - Pointer to Key Map Node
  364.  * returns:    LoadSeg - Pointer to LoadSeg
  365.  */
  366. ULONG MakeCodeSeg(KeyMapNode, filename)
  367. struct KeyMapNode *KeyMapNode;
  368. char *filename;
  369. {
  370.     UBYTE *Segment;
  371.     struct KeyMap *KeyMap;
  372.     ULONG    *NewKeyMap;
  373.     struct HalfKeyMap *HalfKeyMap, *NewHalfKeyMap;
  374.     USHORT    KeyCode;
  375.     int    maphalf;
  376.     ULONG    SegmentLen, len, offset;
  377.     UBYTE    headerlen;
  378.  
  379.     len = sizeof(struct KeyMap_Hunk);
  380.     HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap;
  381.     maphalf = 0;
  382.     KeyCode = 0x00;
  383.     while (maphalf < 2)
  384.         if (((maphalf == 0) && (KeyCode < 0x40)) || ((maphalf == 1) && (KeyCode < 0x38))) {
  385.             switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  386.                 case KCF_STRING:
  387.                     len += StringKeyLength(HalfKeyMap, KeyCode, &headerlen);
  388.                     break;    
  389.                 case KCF_DEAD:
  390.                     len += DeadKeyLength(HalfKeyMap, KeyCode, &headerlen);
  391.             } /* switch */
  392.             KeyCode += 1;
  393.         }
  394.         else {
  395.             KeyCode = 0x00;
  396.             HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap.km_HiKeyMapTypes;
  397.             maphalf += 1;
  398.         }
  399.     len += strlen(filename) + 1;
  400.     len = (len & 0x03)?((len & ~0x03)+4):len;
  401.  
  402.     if ((CodeSegment = (struct KeyMap_Hunk *)AllocMem(len, MEMF_CLEAR)) == NULL) {
  403.         Write(Output(), "Memory Allocation Failed, MakeCodeSeg:CodeSegment\n", 50);
  404.         return(NULL);
  405.     }
  406.     SegmentLen = (len>>2) - 2;
  407.  
  408.     CodeSegment->Hunk = HUNK_CODE;
  409.     CodeSegment->Length = SegmentLen;
  410.     Segment = (UBYTE *)&CodeSegment->kh_KeyMapNode;
  411.     offset = sizeof(struct KeyMap_Hunk) - 8;
  412.     memcpy(Segment, (UBYTE *)KeyMapNode, offset);
  413.  
  414.     KeyMap = &CodeSegment->kh_KeyMapNode.kn_KeyMap;
  415.     KeyMap->km_LoKeyMapTypes = (UBYTE *)((ULONG)&CodeSegment->kh_LoKeyMapTypes - (ULONG)&CodeSegment->kh_KeyMapNode);
  416.     if (!InsertRelocList((ULONG)&KeyMap->km_LoKeyMapTypes - (ULONG)&CodeSegment->kh_KeyMapNode))
  417.         return(NULL);
  418.     KeyMap->km_LoKeyMap = (ULONG *)((ULONG)&CodeSegment->kh_LoKeyMap - (ULONG)&CodeSegment->kh_KeyMapNode);
  419.     if (!InsertRelocList((ULONG)&KeyMap->km_LoKeyMap - (ULONG)&CodeSegment->kh_KeyMapNode))
  420.         return(NULL);
  421.     KeyMap->km_LoCapsable = (UBYTE *)((ULONG)&CodeSegment->kh_LoCapsable - (ULONG)&CodeSegment->kh_KeyMapNode);
  422.     if (!InsertRelocList((ULONG)&KeyMap->km_LoCapsable - (ULONG)&CodeSegment->kh_KeyMapNode))
  423.         return(NULL);
  424.     KeyMap->km_LoRepeatable = (UBYTE *)((ULONG)&CodeSegment->kh_LoRepeatable - (ULONG)&CodeSegment->kh_KeyMapNode);
  425.     if (!InsertRelocList((ULONG)&KeyMap->km_LoRepeatable - (ULONG)&CodeSegment->kh_KeyMapNode))
  426.         return(NULL);
  427.     KeyMap->km_HiKeyMapTypes = (UBYTE *)((ULONG)&CodeSegment->kh_HiKeyMapTypes - (ULONG)&CodeSegment->kh_KeyMapNode);
  428.     if (!InsertRelocList((ULONG)&KeyMap->km_HiKeyMapTypes - (ULONG)&CodeSegment->kh_KeyMapNode))
  429.         return(NULL);
  430.     KeyMap->km_HiKeyMap = (ULONG *)((ULONG)&CodeSegment->kh_HiKeyMap - (ULONG)&CodeSegment->kh_KeyMapNode);
  431.     if (!InsertRelocList((ULONG)&KeyMap->km_HiKeyMap - (ULONG)&CodeSegment->kh_KeyMapNode))
  432.         return(NULL);
  433.     KeyMap->km_HiCapsable = (UBYTE *)((ULONG)&CodeSegment->kh_HiCapsable - (ULONG)&CodeSegment->kh_KeyMapNode);
  434.     if (!InsertRelocList((ULONG)&KeyMap->km_HiCapsable - (ULONG)&CodeSegment->kh_KeyMapNode))
  435.         return(NULL);
  436.     KeyMap->km_HiRepeatable = (UBYTE *)((ULONG)&CodeSegment->kh_HiRepeatable - (ULONG)&CodeSegment->kh_KeyMapNode);
  437.     if (!InsertRelocList((ULONG)&KeyMap->km_HiRepeatable - (ULONG)&CodeSegment->kh_KeyMapNode))
  438.         return(NULL);
  439.  
  440.     HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap;
  441.     NewKeyMap = CodeSegment->kh_LoKeyMap;
  442.     NewHalfKeyMap = (struct HalfKeyMap *)&CodeSegment->kh_KeyMapNode.kn_KeyMap;
  443.     maphalf = 0;
  444.     KeyCode = 0x00;
  445.     while (maphalf < 2)
  446.         if (((maphalf == 0) && (KeyCode < 0x40)) || ((maphalf == 1) && (KeyCode < 0x38))) {
  447.             switch (HalfKeyMap->KeyMapTypes[KeyCode] & (KCF_STRING|KCF_DEAD|KCF_NOP)) {
  448.                 case KCF_STRING:
  449.                     len = StringKeyLength(HalfKeyMap, KeyCode, &headerlen);
  450.                     len = CopyStringKey(HalfKeyMap, KeyCode, &Segment[offset], headerlen);
  451.                     NewKeyMap[KeyCode] = offset;
  452.                     if (!InsertRelocList((ULONG)&NewHalfKeyMap->KeyMap[KeyCode]))
  453.                         return(NULL);
  454.                     offset += len;
  455.                     break;    
  456.                 case KCF_DEAD:
  457.                     len = DeadKeyLength(HalfKeyMap, KeyCode, &headerlen);
  458.                     len = CopyDeadKey(HalfKeyMap, KeyCode, &Segment[offset], headerlen);
  459.                     NewKeyMap[KeyCode] = offset;
  460.                     if (!InsertRelocList((ULONG)&NewHalfKeyMap->KeyMap[KeyCode]))
  461.                         return(NULL);
  462.                     offset += len;
  463.             } /* switch */
  464.             KeyCode += 1;
  465.         }
  466.         else {
  467.             KeyCode = 0x00;
  468.             HalfKeyMap = (struct HalfKeyMap *)&KeyMapNode->kn_KeyMap.km_HiKeyMapTypes;
  469.             NewKeyMap = CodeSegment->kh_HiKeyMap;
  470.             NewHalfKeyMap = (struct HalfKeyMap *)&CodeSegment->kh_KeyMapNode.kn_KeyMap.km_HiKeyMapTypes;
  471.             maphalf += 1;
  472.         }
  473.     len = strlen(filename) + 1;
  474.     memcpy(&Segment[offset], filename, len);
  475.     CodeSegment->kh_KeyMapNode.kn_Node.ln_Name = (UBYTE *)offset;
  476.     if (!InsertRelocList((ULONG)&CodeSegment->kh_KeyMapNode.kn_Node.ln_Name - (ULONG)Segment))
  477.         return(NULL);
  478.     return((SegmentLen+2)<<2);
  479. }
  480.  
  481. /*
  482.  * Insert Reloc List
  483.  *
  484.  * parameter:    Offset - offset of pointer
  485.  * return:    Success - TRUE if success
  486.  */
  487. int InsertRelocList(offset)
  488. ULONG    offset;
  489. {
  490.     struct RelocNode *new, *temp, *prev;
  491.  
  492.     prev = NULL;
  493.     for (temp = RelocList; (temp != NULL) && (temp->Offset > offset); temp = temp->Next)
  494.         prev = temp;
  495.     if ((new = (struct RelocNode *)AllocMem(sizeof(struct RelocNode), MEMF_CLEAR)) == NULL) {
  496.         Write(Output(), "Memory Allocation Failed, InsertRelocList\n", 42);
  497.         return(FALSE);
  498.     }
  499.     new->Offset = offset;
  500.     new->Next = temp;
  501.     if (prev == NULL)
  502.         RelocList = new;
  503.     else
  504.         prev->Next = new;
  505.     return(TRUE);
  506. }
  507.